JavaScript Development Environment: Docker Container Configuration

నేటి వేగవంతమైన సాఫ్ట్‌వేర్ అభివృద్ధిలో, స్థిరమైన మరియు పునరుత్పత్తి చేయగల అభివృద్ధి వాతావరణాన్ని నిర్వహించడం చాలా ముఖ్యం. విభిన్న ఆపరేటింగ్ సిస్టమ్‌లు, మారుతున్న సాఫ్ట్‌వేర్ వెర్షన్‌లు మరియు వైరుధ్యమైన డిపెండెన్సీలు "ఇది నా మెషీన్‌లో పనిచేస్తుంది" అనే భయంకరమైన సిండ్రోమ్‌కు దారితీయవచ్చు. డాకర్, ఒక ప్రముఖ కంటైనరైజేషన్ ప్లాట్‌ఫారమ్, ఈ సమస్యకు శక్తివంతమైన పరిష్కారాన్ని అందిస్తుంది, డెవలపర్‌లు వారి అప్లికేషన్‌ను మరియు దాని డిపెండెన్సీలను ఒకే, ఐసోలేటెడ్ యూనిట్‌గా ప్యాక్ చేయడానికి అనుమతిస్తుంది.

ఈ గైడ్ డాకర్ కంటైనర్‌లను ఉపయోగించి పటిష్టమైన మరియు స్థిరమైన జావాస్క్రిప్ట్ అభివృద్ధి వాతావరణాన్ని ఏర్పాటు చేసే ప్రక్రియ ద్వారా మిమ్మల్ని నడిపిస్తుంది. మీ బృందం యొక్క విభిన్న ఆపరేటింగ్ సిస్టమ్‌లతో సంబంధం లేకుండా, మీ జావాస్క్రిప్ట్ ప్రాజెక్ట్‌ల కోసం సున్నితమైన మరియు సమర్థవంతమైన వర్క్‌ఫ్లోను నిర్ధారిస్తూ, ప్రాథమిక సెటప్ నుండి ఆధునిక కాన్ఫిగరేషన్‌ల వరకు ప్రతిదీ మేము కవర్ చేస్తాము.

JavaScript అభివృద్ధి కోసం డాకర్‌ను ఎందుకు ఉపయోగించాలి?

ప్రత్యేకతల్లోకి ప్రవేశించే ముందు, మీ జావాస్క్రిప్ట్ అభివృద్ధి వాతావరణం కోసం డాకర్‌ను ఉపయోగించడం వల్ల కలిగే ప్రయోజనాలను అన్వేషిద్దాం:

• స్థిరత్వం: డాకర్ మీ బృందంలోని ప్రతి ఒక్కరూ ఖచ్చితంగా ఒకే వాతావరణంతో పనిచేస్తున్నారని నిర్ధారిస్తుంది, అనుకూలత సమస్యలను తొలగిస్తుంది మరియు పర్యావరణ వ్యత్యాసాల వల్ల సంభవించే లోపాల సంభావ్యతను తగ్గిస్తుంది. భౌగోళికంగా పంపిణీ చేయబడిన బృందాలకు ఇది చాలా ముఖ్యం.
• ఐసోలేషన్: కంటైనర్‌లు హోస్ట్ సిస్టమ్ నుండి ఐసోలేషన్‌ను అందిస్తాయి, ఇతర ప్రాజెక్ట్‌లతో వైరుధ్యాలను నిరోధిస్తాయి మరియు మీ డిపెండెన్సీలు ఒకదానితో ఒకటి జోక్యం చేసుకోకుండా చూస్తాయి.
• పునరుత్పత్తి: డాకర్ చిత్రాలను సులభంగా భాగస్వామ్యం చేయవచ్చు మరియు విస్తరించవచ్చు, విభిన్న యంత్రాలలో లేదా ఉత్పత్తిలో మీ అభివృద్ధి వాతావరణాన్ని పునరుత్పత్తి చేయడం సులభం చేస్తుంది. కొత్త బృంద సభ్యులను నియమించేటప్పుడు లేదా వేర్వేరు క్లౌడ్ ప్రొవైడర్‌లకు విస్తరించేటప్పుడు ఇది ప్రత్యేకంగా సహాయపడుతుంది.
• పోర్టబిలిటీ: డాకర్ కంటైనర్‌లు విండోస్, macOS మరియు Linuxతో సహా డాకర్‌కు మద్దతు ఇచ్చే ఏదైనా ప్లాట్‌ఫారమ్‌లో రన్ చేయగలవు, డెవలపర్‌లు ప్రాజెక్ట్‌ను ప్రభావితం చేయకుండా వారి ప్రాధాన్య ఆపరేటింగ్ సిస్టమ్‌ను ఉపయోగించడానికి అనుమతిస్తుంది.
• సరళీకృత విస్తరణ: అభివృద్ధి కోసం ఉపయోగించిన అదే డాకర్ ఇమేజ్‌ను పరీక్ష మరియు ఉత్పత్తి కోసం ఉపయోగించవచ్చు, విస్తరణ ప్రక్రియను క్రమబద్ధీకరిస్తుంది మరియు లోపాల ప్రమాదాన్ని తగ్గిస్తుంది.

ముందస్తు అవసరాలు

మీరు ప్రారంభించే ముందు, మీరు ఈ క్రింది వాటిని ఇన్‌స్టాల్ చేశారని నిర్ధారించుకోండి:

• డాకర్: అధికారిక డాకర్ వెబ్‌సైట్ (docker.com) నుండి మీ ఆపరేటింగ్ సిస్టమ్ కోసం డాకర్ డెస్క్‌టాప్‌ను డౌన్‌లోడ్ చేసి, ఇన్‌స్టాల్ చేయండి. డాకర్ డెస్క్‌టాప్‌లో డాకర్ ఇంజిన్, డాకర్ CLI, డాకర్ కంపోజ్ మరియు ఇతర ముఖ్యమైన టూల్స్ ఉన్నాయి.
• Node.js మరియు npm (ఐచ్ఛికం): అవి కంటైనర్‌లో ఉంటాయి కాబట్టి మీ హోస్ట్ మెషీన్‌లో ఖచ్చితంగా అవసరం లేదు, Node.js మరియు npm స్థానికంగా ఇన్‌స్టాల్ చేయడం కంటైనర్ వెలుపల లేదా మీ ప్రారంభ ప్రాజెక్ట్ నిర్మాణాన్ని ఏర్పాటు చేసేటప్పుడు సహాయపడుతుంది. మీరు వాటిని nodejs.org నుండి డౌన్‌లోడ్ చేసుకోవచ్చు.
• కోడ్ ఎడిటర్: మీకు ఇష్టమైన కోడ్ ఎడిటర్‌ను ఎంచుకోండి (ఉదా., VS కోడ్, సబ్‌లైమ్ టెక్స్ట్, ఆటమ్). VS కోడ్ మీ వర్క్‌ఫ్లోను సులభతరం చేసే అద్భుతమైన డాకర్ పొడిగింపులను కలిగి ఉంది.

ప్రాథమిక డాకర్‌ఫైల్ కాన్ఫిగరేషన్

ఏదైనా డాకర్-ఆధారిత పర్యావరణానికి పునాది Dockerfile. ఈ ఫైల్ మీ డాకర్ ఇమేజ్‌ను రూపొందించడానికి సూచనలను కలిగి ఉంది. Node.js అప్లికేషన్ కోసం ప్రాథమిక Dockerfileను సృష్టిద్దాం:

# పేరెంట్ ఇమేజ్‌గా అధికారిక Node.js రన్‌టైమ్‌ను ఉపయోగించండి
FROM node:18-alpine

# కంటైనర్‌లో పని చేసే డైరెక్టరీని సెట్ చేయండి
WORKDIR /app

# package.json మరియు package-lock.jsonని పని చేసే డైరెక్టరీకి కాపీ చేయండి
COPY package*.json ./

# అప్లికేషన్ డిపెండెన్సీలను ఇన్‌స్టాల్ చేయండి
RUN npm install

# అప్లికేషన్ సోర్స్ కోడ్‌ను పని చేసే డైరెక్టరీకి కాపీ చేయండి
COPY .\t.

# వెలుపలి ప్రపంచానికి పోర్ట్ 3000ని ఎక్స్పోజ్ చేయండి (మీ యాప్ వేరే పోర్ట్‌ను ఉపయోగిస్తే సర్దుబాటు చేయండి)
EXPOSE 3000

# కంటైనర్ ప్రారంభమైనప్పుడు రన్ చేయడానికి ఆదేశాన్ని నిర్వచించండి
CMD ["npm", "start"]

ప్రతి లైన్‌ను విశ్లేషిద్దాం:

• FROM node:18-alpine: కంటైనర్ కోసం బేస్ ఇమేజ్‌ను పేర్కొంటుంది. ఈ సందర్భంలో, మేము అధికారిక Node.js 18 ఆల్పైన్ ఇమేజ్‌ను ఉపయోగిస్తున్నాము, ఇది తేలికపాటి Linux పంపిణీ. ఆల్పైన్ దాని చిన్న పరిమాణానికి ప్రసిద్ధి చెందింది, ఇది మీ డాకర్ ఇమేజ్‌ను సన్నగా ఉంచడంలో సహాయపడుతుంది. మీ ప్రాజెక్ట్ కోసం తగిన ఇతర Node.js వెర్షన్‌లను పరిశీలించండి.
• WORKDIR /app: కంటైనర్‌లోని పని చేసే డైరెక్టరీని /appకి సెట్ చేస్తుంది. మీ అప్లికేషన్ కోడ్ ఇక్కడ ఉంటుంది.
• COPY package*.json ./: package.json మరియు package-lock.json (లేదా మీరు Yarn ఉపయోగిస్తే yarn.lock) ఫైల్‌లను పని చేసే డైరెక్టరీకి కాపీ చేస్తుంది. ఈ ఫైల్‌లను మొదట కాపీ చేయడం వలన డాకర్ npm install దశను కాష్ చేయడానికి అనుమతిస్తుంది, మీరు అప్లికేషన్ కోడ్‌ను మాత్రమే మార్చినప్పుడు బిల్డ్ సమయాన్ని గణనీయంగా పెంచుతుంది.
• RUN npm install: package.jsonలో నిర్వచించిన అప్లికేషన్ డిపెండెన్సీలను ఇన్‌స్టాల్ చేస్తుంది.
• COPY . .: మీ స్థానిక ప్రాజెక్ట్ డైరెక్టరీ నుండి మిగిలిన అన్ని ఫైల్‌లు మరియు డైరెక్టరీలను కంటైనర్‌లోని పని చేసే డైరెక్టరీకి కాపీ చేస్తుంది.
• EXPOSE 3000: పోర్ట్ 3000ని ఎక్స్‌పోజ్ చేస్తుంది, హోస్ట్ మెషీన్ నుండి యాక్సెస్ చేయడానికి వీలు కల్పిస్తుంది. మీ అప్లికేషన్ ఈ పోర్ట్‌లో వింటుంటే ఇది ముఖ్యం. మీ అప్లికేషన్ వేరే పోర్ట్‌ను ఉపయోగిస్తే పోర్ట్ నంబర్‌ను సర్దుబాటు చేయండి.
• CMD ["npm", "start"]: కంటైనర్ ప్రారంభమైనప్పుడు రన్ చేయడానికి ఆదేశాన్ని పేర్కొంటుంది. ఈ సందర్భంలో, మేము npm startను ఉపయోగిస్తున్నాము, ఇది Node.js అప్లికేషన్‌లను ప్రారంభించడానికి సాధారణ ఆదేశం. ఈ ఆదేశం మీ package.jsonలోని scripts విభాగంలో నిర్వచించబడిన ఆదేశానికి సరిపోలుతుందని నిర్ధారించుకోండి.

డాకర్ ఇమేజ్‌ను రూపొందించడం

మీరు మీ Dockerfileను సృష్టించిన తర్వాత, మీరు ఈ క్రింది ఆదేశాన్ని ఉపయోగించి డాకర్ ఇమేజ్‌ను రూపొందించవచ్చు:

docker build -t my-node-app .

ఇక్కడ:

• docker build: ఇమేజ్‌లను రూపొందించడానికి డాకర్ ఆదేశం.
• -t my-node-app: ఇమేజ్ కోసం ట్యాగ్‌ను (పేరు) పేర్కొంటుంది. మీ అప్లికేషన్ కోసం వివరణాత్మక పేరును ఎంచుకోండి.
• .: బిల్డ్ సందర్భాన్ని పేర్కొంటుంది, ఇది ప్రస్తుత డైరెక్టరీ. డాకర్ ఈ డైరెక్టరీలోని Dockerfileని ఉపయోగించి ఇమేజ్‌ను రూపొందిస్తుంది.

డాకర్ మీ Dockerfileలోని సూచనలను అమలు చేస్తుంది, ఇమేజ్‌ను పొర ద్వారా పొరగా రూపొందిస్తుంది. మీరు మొదటిసారి ఇమేజ్‌ను రూపొందించినప్పుడు, బేస్ ఇమేజ్‌ను డౌన్‌లోడ్ చేయడానికి మరియు డిపెండెన్సీలను ఇన్‌స్టాల్ చేయడానికి కొంత సమయం పట్టవచ్చు. అయితే, డాకర్ ఇంటర్మీడియట్ లేయర్‌లను కాష్ చేయడం వలన తదుపరి బిల్డ్‌లు చాలా వేగంగా ఉంటాయి.

డాకర్ కంటైనర్‌ను రన్ చేయడం

ఇమేజ్ రూపొందిన తర్వాత, మీరు ఈ క్రింది ఆదేశాన్ని ఉపయోగించి దాని నుండి కంటైనర్‌ను రన్ చేయవచ్చు:

docker run -p 3000:3000 my-node-app

ఇక్కడ:

• docker run: కంటైనర్‌లను రన్ చేయడానికి డాకర్ ఆదేశం.
• -p 3000:3000: హోస్ట్ మెషీన్‌లోని పోర్ట్ 3000ని కంటైనర్‌లోని పోర్ట్ 3000కి మ్యాప్ చేస్తుంది. ఇది localhost:3000ని ఉపయోగించి మీ బ్రౌజర్ నుండి మీ అప్లికేషన్‌ను యాక్సెస్ చేయడానికి మిమ్మల్ని అనుమతిస్తుంది. మొదటి సంఖ్య హోస్ట్ పోర్ట్, మరియు రెండవ సంఖ్య కంటైనర్ పోర్ట్.
• my-node-app: మీరు రన్ చేయాలనుకుంటున్న ఇమేజ్ పేరు.

మీ అప్లికేషన్ ఇప్పుడు డాకర్ కంటైనర్‌లో రన్ అవుతూ ఉండాలి. మీ బ్రౌజర్‌ను తెరిచి localhost:3000కి (లేదా మీరు పేర్కొన్న పోర్ట్‌కు) నావిగేట్ చేయడం ద్వారా మీరు దాన్ని యాక్సెస్ చేయవచ్చు. మీరు మీ అప్లికేషన్ యొక్క స్వాగత స్క్రీన్ లేదా ప్రారంభ UIని చూడాలి.

డాకర్ కంపోజ్‌ను ఉపయోగించడం

బహుళ సేవలతో కూడిన మరింత సంక్లిష్టమైన అప్లికేషన్‌ల కోసం, డాకర్ కంపోజ్ ఒక అమూల్యమైన టూల్. ఇది YAML ఫైల్‌ను ఉపయోగించి బహుళ-కంటైనర్ అప్లికేషన్‌లను నిర్వచించడానికి మరియు నిర్వహించడానికి మిమ్మల్ని అనుమతిస్తుంది. మా Node.js అప్లికేషన్ కోసం docker-compose.yml ఫైల్‌ను సృష్టిద్దాం:

version: "3.9"
services:
  app:
    build: .
    ports:
      - "3000:3000"
    volumes:
      - .:/app
    environment:
      NODE_ENV: development
    command: npm run dev

ప్రతి విభాగాన్ని పరిశీలిద్దాం:

• version: "3.9": డాకర్ కంపోజ్ ఫైల్ ఫార్మాట్ యొక్క వెర్షన్‌ను పేర్కొంటుంది.
• services: మీ అప్లికేషన్‌ను రూపొందించే సేవలను నిర్వచిస్తుంది. ఈ సందర్భంలో, మాకు app అనే ఒకే సేవ ఉంది.
• build: .: ప్రస్తుత డైరెక్టరీలోని Dockerfile నుండి ఇమేజ్‌ను రూపొందించాలని పేర్కొంటుంది.
• ports: - "3000:3000": docker run ఆదేశానికి సమానంగా, హోస్ట్ మెషీన్‌లోని పోర్ట్ 3000ని కంటైనర్‌లోని పోర్ట్ 3000కి మ్యాప్ చేస్తుంది.
• volumes: - .:/app: మీ హోస్ట్ మెషీన్‌లోని ప్రస్తుత డైరెక్టరీని కంటైనర్‌లోని /app డైరెక్టరీకి మౌంట్ చేసే వాల్యూమ్‌ను సృష్టిస్తుంది. ఇది హోస్ట్ మెషీన్‌లో మీ కోడ్‌కు మార్పులు చేయడానికి మరియు వాటిని కంటైనర్‌లో స్వయంచాలకంగా ప్రతిబింబించేలా చేయడానికి మిమ్మల్ని అనుమతిస్తుంది, హాట్ రీలోడింగ్‌ను ప్రారంభిస్తుంది.
• environment: NODE_ENV: development: కంటైనర్‌లోని NODE_ENV ఎన్విరాన్‌మెంట్ వేరియబుల్‌ను developmentకి సెట్ చేస్తుంది. డెవలప్‌మెంట్ మోడ్‌లో రన్ చేయడానికి మీ అప్లికేషన్‌ను కాన్ఫిగర్ చేయడానికి ఇది ఉపయోగపడుతుంది.
• command: npm run dev: Dockerfileలో నిర్వచించబడిన డిఫాల్ట్ ఆదేశాన్ని ఓవర్‌రైడ్ చేస్తుంది. ఈ సందర్భంలో, మేము npm run devని ఉపయోగిస్తున్నాము, ఇది తరచుగా హాట్ రీలోడింగ్‌తో డెవలప్‌మెంట్ సర్వర్‌ను ప్రారంభించడానికి ఉపయోగించబడుతుంది.

డాకర్ కంపోజ్‌ను ఉపయోగించి అప్లికేషన్‌ను ప్రారంభించడానికి, docker-compose.yml ఫైల్ ఉన్న డైరెక్టరీకి నావిగేట్ చేసి, ఈ క్రింది ఆదేశాన్ని అమలు చేయండి:

docker-compose up

డాకర్ కంపోజ్ ఇమేజ్‌ను రూపొందిస్తుంది (అవసరమైతే) మరియు కంటైనర్‌ను ప్రారంభిస్తుంది. కంటైనర్‌ను డిటాచ్డ్ మోడ్‌లో (బ్యాక్‌గ్రౌండ్‌లో) రన్ చేయడానికి -d ఫ్లాగ్‌ను జోడించవచ్చు.

ఆధునిక కాన్ఫిగరేషన్ ఎంపికలు

మీ డాకర్‌రైజ్డ్ జావాస్క్రిప్ట్ అభివృద్ధి వాతావరణాన్ని మెరుగుపరచడానికి కొన్ని ఆధునిక కాన్ఫిగరేషన్ ఎంపికలు ఇక్కడ ఉన్నాయి:

1. మల్టీ-స్టేజ్ బిల్డ్‌లు

మల్టీ-స్టేజ్ బిల్డ్‌లు మీ Dockerfileలో బహుళ FROM సూచనలను ఉపయోగించడానికి మిమ్మల్ని అనుమతిస్తాయి, ప్రతి ఒక్కటి వేర్వేరు బిల్డ్ దశను సూచిస్తుంది. బిల్డ్ వాతావరణాన్ని రన్‌టైమ్ వాతావరణం నుండి వేరు చేయడం ద్వారా మీ ఫైనల్ ఇమేజ్ పరిమాణాన్ని తగ్గించడానికి ఇది ఉపయోగపడుతుంది.

# దశ 1: అప్లికేషన్‌ను రూపొందించండి
FROM node:18-alpine AS builder
WORKDIR /app
COPY package*.json ./
RUN npm install
COPY .\t.
RUN npm run build

# దశ 2: రన్‌టైమ్ ఇమేజ్‌ను సృష్టించండి
FROM nginx:alpine
COPY --from=builder /app/dist /usr/share/nginx/html
EXPOSE 80
CMD ["nginx", "-g", "daemon off;"]

ఈ ఉదాహరణలో, మొదటి దశ (builder) Node.jsని ఉపయోగించి అప్లికేషన్‌ను రూపొందిస్తుంది. రెండవ దశ Nginxని ఉపయోగించి నిర్మించిన అప్లికేషన్ ఫైల్‌లను అందిస్తుంది. మొదటి దశ నుండి నిర్మించిన ఫైల్‌లు మాత్రమే రెండవ దశకు కాపీ చేయబడతాయి, దీని ఫలితంగా చిన్న మరియు మరింత సమర్థవంతమైన ఇమేజ్ వస్తుంది.

2. ఎన్విరాన్‌మెంట్ వేరియబుల్స్‌ను ఉపయోగించడం

కోడ్‌ను సవరించకుండా మీ అప్లికేషన్‌ను కాన్ఫిగర్ చేయడానికి ఎన్విరాన్‌మెంట్ వేరియబుల్స్ ఒక శక్తివంతమైన మార్గం. మీరు మీ docker-compose.yml ఫైల్‌లో ఎన్విరాన్‌మెంట్ వేరియబుల్స్‌ను నిర్వచించవచ్చు లేదా -e ఫ్లాగ్‌ను ఉపయోగించి రన్‌టైమ్‌లో వాటిని పాస్ చేయవచ్చు.

services:
  app:
    environment:
      API_URL: "http://api.example.com"

మీ అప్లికేషన్‌లోపల, మీరు process.envని ఉపయోగించి ఈ ఎన్విరాన్‌మెంట్ వేరియబుల్స్‌ను యాక్సెస్ చేయవచ్చు.

const apiUrl = process.env.API_URL;

3. అభివృద్ధి కోసం వాల్యూమ్ మౌంటింగ్

వాల్యూమ్ మౌంటింగ్ (డాకర్ కంపోజ్ ఉదాహరణలో చూపిన విధంగా) అభివృద్ధికి చాలా కీలకం, ఎందుకంటే ఇది హోస్ట్ మెషీన్‌లో మీ కోడ్‌కు మార్పులు చేయడానికి మరియు వాటిని వెంటనే కంటైనర్‌లో ప్రతిబింబించేలా చేయడానికి మిమ్మల్ని అనుమతిస్తుంది. ప్రతిసారీ మీరు మార్పు చేసినప్పుడు ఇమేజ్‌ను పునర్నిర్మించాల్సిన అవసరాన్ని ఇది తొలగిస్తుంది.

4. VS కోడ్‌తో డీబగ్గింగ్

డాకర్ కంటైనర్‌లలో రన్ అవుతున్న Node.js అప్లికేషన్‌లను డీబగ్ చేయడానికి VS కోడ్ అద్భుతమైన మద్దతును కలిగి ఉంది. రన్ అవుతున్న కంటైనర్‌కు అటాచ్ చేయడానికి మరియు బ్రేక్‌పాయింట్‌లను సెట్ చేయడానికి, వేరియబుల్స్‌ను తనిఖీ చేయడానికి మరియు మీ కోడ్ ద్వారా స్టెప్ చేయడానికి మీరు VS కోడ్ డాకర్ ఎక్స్‌టెన్షన్‌ను ఉపయోగించవచ్చు.

మొదట, VS కోడ్‌లో డాకర్ ఎక్స్‌టెన్షన్‌ను ఇన్‌స్టాల్ చేయండి. ఆపై, ఈ క్రింది కాన్ఫిగరేషన్‌తో మీ .vscode డైరెక్టరీలో launch.json ఫైల్‌ను సృష్టించండి:

{
  "version": "0.2.0",
  "configurations": [
    {
      "type": "node",
      "request": "attach",
      "name": "Attach to Docker",
      "port": 9229,
      "address": "localhost",
      "remoteRoot": "/app",
      "localRoot": "${workspaceFolder}"
    }
  ]
}

మీ Node.js అప్లికేషన్ --inspect లేదా --inspect-brk ఫ్లాగ్‌తో ప్రారంభించబడిందని నిర్ధారించుకోండి. ఉదాహరణకు, ఈ ఫ్లాగ్‌ను చేర్చడానికి మీరు మీ docker-compose.yml ఫైల్‌ను సవరించవచ్చు:

services:
  app:
    command: npm run dev -- --inspect=0.0.0.0:9229

ఆపై, VS కోడ్‌లో, "Attach to Docker" కాన్ఫిగరేషన్‌ను ఎంచుకుని, డీబగ్గింగ్‌ను ప్రారంభించండి. మీరు బ్రేక్‌పాయింట్‌లను సెట్ చేయగలరు మరియు కంటైనర్‌లో రన్ అవుతున్న మీ కోడ్‌ను డీబగ్ చేయగలరు.

5. ప్రైవేట్ npm రిజిస్ట్రీని ఉపయోగించడం

మీరు ప్రైవేట్ npm ప్యాకేజీలతో ప్రాజెక్ట్‌లో పని చేస్తుంటే, మీ ప్రైవేట్ npm రిజిస్ట్రీతో ప్రమాణీకరించడానికి మీరు మీ డాకర్ కంటైనర్‌ను కాన్ఫిగర్ చేయాలి. మీ docker-compose.yml ఫైల్‌లో NPM_TOKEN ఎన్విరాన్‌మెంట్ వేరియబుల్‌ను సెట్ చేయడం ద్వారా లేదా మీ ప్రాజెక్ట్ డైరెక్టరీలో .npmrc ఫైల్‌ను సృష్టించడం ద్వారా మరియు దానిని కంటైనర్‌కు కాపీ చేయడం ద్వారా ఇది చేయవచ్చు.

# Dockerfile
FROM node:18-alpine
WORKDIR /app
COPY package*.json ./
COPY .npmrc .
RUN npm install
COPY .\t.
EXPOSE 3000
CMD ["npm", "start"]

`.npmrc` ఫైల్‌లో మీ ప్రమాణీకరణ టోకెన్ ఉండాలి:

//registry.npmjs.org/:_authToken=YOUR_NPM_TOKEN

YOUR_NPM_TOKENని మీ అసలు npm టోకెన్‌తో భర్తీ చేయడానికి గుర్తుంచుకోండి. ఈ టోకెన్‌ను సురక్షితంగా ఉంచండి మరియు మీ పబ్లిక్ రిపోజిటరీకి కమిట్ చేయవద్దు.

6. ఇమేజ్ పరిమాణాన్ని ఆప్టిమైజ్ చేయడం

వేగవంతమైన బిల్డ్ మరియు విస్తరణ సమయాల కోసం మీ డాకర్ ఇమేజ్ పరిమాణాన్ని చిన్నగా ఉంచడం ముఖ్యం. ఇమేజ్ పరిమాణాన్ని ఆప్టిమైజ్ చేయడానికి కొన్ని చిట్కాలు ఇక్కడ ఉన్నాయి:

• node:alpine వంటి తేలికపాటి బేస్ ఇమేజ్‌ను ఉపయోగించండి.
• బిల్డ్ వాతావరణాన్ని రన్‌టైమ్ వాతావరణం నుండి వేరు చేయడానికి మల్టీ-స్టేజ్ బిల్డ్‌లను ఉపయోగించండి.
• ఇమేజ్ నుండి అనవసరమైన ఫైల్‌లు మరియు డైరెక్టరీలను తీసివేయండి.
• బిల్డ్ సందర్భం నుండి ఫైల్‌లు మరియు డైరెక్టరీలను మినహాయించడానికి .dockerignore ఫైల్‌ను ఉపయోగించండి.
• లేయర్‌ల సంఖ్యను తగ్గించడానికి బహుళ RUN ఆదేశాలను ఒకే ఆదేశంలో కలపండి.

ఉదాహరణ: రియాక్ట్ అప్లికేషన్‌ను డాకర్‌రైజ్ చేయడం

క్రియేట్ రియాక్ట్ యాప్‌తో సృష్టించబడిన రియాక్ట్ అప్లికేషన్‌ను డాకర్‌రైజ్ చేయడం: ఒక ఆచరణాత్మక ఉదాహరణతో ఈ భావనలను వివరిద్దాం.

మొదట, క్రియేట్ రియాక్ట్ యాప్‌ను ఉపయోగించి కొత్త రియాక్ట్ అప్లికేషన్‌ను సృష్టించండి:

npx create-react-app my-react-app
cd my-react-app

ఆపై, ప్రాజెక్ట్ యొక్క రూట్ డైరెక్టరీలో Dockerfileను సృష్టించండి:

FROM node:18-alpine AS builder
WORKDIR /app
COPY package*.json ./
RUN npm install
COPY .\t.
RUN npm run build

FROM nginx:alpine
COPY --from=builder /app/build /usr/share/nginx/html
EXPOSE 80
CMD ["nginx", "-g", "daemon off;"]

docker-compose.yml ఫైల్‌ను సృష్టించండి:

version: "3.9"
services:
  app:
    build: .
    ports:
      - "3000:80"
    volumes:
      - .:/app
    environment:
      NODE_ENV: development

గమనిక: మేము హోస్ట్‌లో పోర్ట్ 3000ని కంటైనర్‌లోని పోర్ట్ 80కి మ్యాప్ చేస్తున్నాము, ఎందుకంటే Nginx పోర్ట్ 80లో అప్లికేషన్‌ను అందిస్తోంది. మీ అప్లికేషన్ కాన్ఫిగరేషన్‌ను బట్టి మీరు పోర్ట్ మ్యాపింగ్‌ను సర్దుబాటు చేయాల్సి ఉంటుంది.

చివరగా, అప్లికేషన్‌ను రూపొందించడానికి మరియు ప్రారంభించడానికి docker-compose upని రన్ చేయండి. మీరు మీ బ్రౌజర్‌లో localhost:3000కి నావిగేట్ చేయడం ద్వారా అప్లికేషన్‌ను యాక్సెస్ చేయవచ్చు.

సాధారణ సమస్యలు మరియు ట్రబుల్షూటింగ్

జాగ్రత్తగా కాన్ఫిగరేషన్‌తో కూడా, మీరు డాకర్‌తో పని చేస్తున్నప్పుడు సమస్యలను ఎదుర్కోవచ్చు. ఇక్కడ కొన్ని సాధారణ సమస్యలు మరియు వాటి పరిష్కారాలు ఉన్నాయి:

• పోర్ట్ వైరుధ్యాలు: మీ docker-compose.yml లేదా docker run ఆదేశంలో మీరు మ్యాప్ చేస్తున్న పోర్ట్‌లు మీ హోస్ట్ మెషీన్‌లోని ఇతర అప్లికేషన్‌ల ద్వారా ఇప్పటికే ఉపయోగించబడలేదని నిర్ధారించుకోండి.
• వాల్యూమ్ మౌంటింగ్ సమస్యలు: మీరు మౌంట్ చేస్తున్న ఫైల్‌లు మరియు డైరెక్టరీలపై అనుమతులను తనిఖీ చేయండి. ఫైల్‌లను యాక్సెస్ చేయడానికి డాకర్‌కు అవసరమైన అనుమతులు ఉండకపోవచ్చు.
• ఇమేజ్ బిల్డ్ వైఫల్యాలు: లోపాల కోసం docker build ఆదేశం యొక్క అవుట్‌పుట్‌ను జాగ్రత్తగా పరిశీలించండి. సాధారణ కారణాలలో సరికాని Dockerfile సింటాక్స్, తప్పిపోయిన డిపెండెన్సీలు లేదా నెట్‌వర్క్ సమస్యలు ఉన్నాయి.
• కంటైనర్ క్రాష్‌లు: మీ కంటైనర్ యొక్క లాగ్‌లను చూడటానికి మరియు క్రాష్‌కు కారణాన్ని గుర్తించడానికి docker logs ఆదేశాన్ని ఉపయోగించండి. సాధారణ కారణాలలో అప్లికేషన్ లోపాలు, తప్పిపోయిన ఎన్విరాన్‌మెంట్ వేరియబుల్స్ లేదా వనరు పరిమితులు ఉన్నాయి.
• నెమ్మదైన బిల్డ్ సమయాలు: మల్టీ-స్టేజ్ బిల్డ్‌లను ఉపయోగించడం, డిపెండెన్సీలను కాష్ చేయడం మరియు లేయర్‌ల సంఖ్యను తగ్గించడం ద్వారా మీ Dockerfileని ఆప్టిమైజ్ చేయండి.

ముగింపు

స్థిరమైన మరియు పునరుత్పత్తి చేయగల జావాస్క్రిప్ట్ అభివృద్ధి వాతావరణాలను సృష్టించడానికి డాకర్ శక్తివంతమైన మరియు బహుముఖ పరిష్కారాన్ని అందిస్తుంది. డాకర్‌ను ఉపయోగించడం ద్వారా, మీరు అనుకూలత సమస్యలను తొలగించవచ్చు, విస్తరణను సులభతరం చేయవచ్చు మరియు మీ బృందంలోని ప్రతి ఒక్కరూ ఒకే వాతావరణంతో పనిచేస్తున్నారని నిర్ధారించుకోవచ్చు.

ఈ గైడ్ డాకర్‌రైజ్డ్ జావాస్క్రిప్ట్ అభివృద్ధి వాతావరణాన్ని ఏర్పాటు చేయడం యొక్క ప్రాథమికాలను, అలాగే కొన్ని ఆధునిక కాన్ఫిగరేషన్ ఎంపికలను కవర్ చేసింది. ఈ దశలను అనుసరించడం ద్వారా, మీరు మీ జావాస్క్రిప్ట్ ప్రాజెక్ట్‌ల కోసం వాటి సంక్లిష్టత లేదా మీ బృందం యొక్క పరిమాణంతో సంబంధం లేకుండా పటిష్టమైన మరియు సమర్థవంతమైన వర్క్‌ఫ్లోను సృష్టించవచ్చు. డాకర్‌ను స్వీకరించండి మరియు మీ జావాస్క్రిప్ట్ అభివృద్ధి ప్రక్రియ యొక్క పూర్తి సామర్థ్యాన్ని అన్‌లాక్ చేయండి.

తదుపరి దశలు:

• మీ నిర్దిష్ట అవసరాలకు సరిపోయే ముందే రూపొందించిన ఇమేజ్‌ల కోసం డాకర్ హబ్‌ను అన్వేషించండి.
• బహుళ-కంటైనర్ అప్లికేషన్‌లను నిర్వహించడానికి డాకర్ కంపోజ్‌లోకి మరింత లోతుగా డైవ్ చేయండి.
• ఉత్పత్తి వాతావరణాలలో డాకర్ కంటైనర్‌లను ఆర్కెస్ట్రేట్ చేయడానికి డాకర్ స్వార్మ్ మరియు కుబెర్‌నెట్స్ గురించి తెలుసుకోండి.

మీ వర్క్‌ఫ్లోలో ఈ ఉత్తమ పద్ధతులను చేర్చడం ద్వారా, మీరు మీ జావాస్క్రిప్ట్ అప్లికేషన్‌ల కోసం మరింత సమర్థవంతమైన, నమ్మదగిన మరియు స్కేలబుల్ అభివృద్ధి వాతావరణాన్ని సృష్టించవచ్చు, నేటి పోటీ మార్కెట్‌లో విజయాన్ని నిర్ధారిస్తుంది.